/*
 *
 *    Copyright (c) 2022 Project CHIP Authors
 *
 *    Licensed under the Apache License, Version 2.0 (the "License");
 *    you may not use this file except in compliance with the License.
 *    You may obtain a copy of the License at
 *
 *        http://www.apache.org/licenses/LICENSE-2.0
 *
 *    Unless required by applicable law or agreed to in writing, software
 *    distributed under the License is distributed on an "AS IS" BASIS,
 *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *    See the License for the specific language governing permissions and
 *    limitations under the License.
 */

// THIS FILE IS GENERATED BY ZAP
// This file is generated from clusters-Commands.h.zapt

#pragma once

#include <app/data-model/DecodableList.h>
#include <app/data-model/Encode.h>
#include <app/data-model/List.h>
#include <app/data-model/NullObject.h>
#include <app/data-model/Nullable.h>
#include <lib/core/DataModelTypes.h>
#include <lib/core/Optional.h>
#include <lib/core/TLV.h>
#include <lib/support/BitMask.h>

#include <clusters/shared/Enums.h>
#include <clusters/shared/Structs.h>

#include <clusters/ColorControl/ClusterId.h>
#include <clusters/ColorControl/CommandIds.h>
#include <clusters/ColorControl/Enums.h>
#include <clusters/ColorControl/Structs.h>

#include <cstdint>

namespace chip
{
namespace app
{
	namespace Clusters
	{
		namespace ColorControl
		{
			namespace Commands
			{
				// Forward-declarations so we can reference these later.

				namespace MoveToHue
				{
					struct Type;
					struct DecodableType;
				} // namespace MoveToHue

				namespace MoveHue
				{
					struct Type;
					struct DecodableType;
				} // namespace MoveHue

				namespace StepHue
				{
					struct Type;
					struct DecodableType;
				} // namespace StepHue

				namespace MoveToSaturation
				{
					struct Type;
					struct DecodableType;
				} // namespace MoveToSaturation

				namespace MoveSaturation
				{
					struct Type;
					struct DecodableType;
				} // namespace MoveSaturation

				namespace StepSaturation
				{
					struct Type;
					struct DecodableType;
				} // namespace StepSaturation

				namespace MoveToHueAndSaturation
				{
					struct Type;
					struct DecodableType;
				} // namespace MoveToHueAndSaturation

				namespace MoveToColor
				{
					struct Type;
					struct DecodableType;
				} // namespace MoveToColor

				namespace MoveColor
				{
					struct Type;
					struct DecodableType;
				} // namespace MoveColor

				namespace StepColor
				{
					struct Type;
					struct DecodableType;
				} // namespace StepColor

				namespace MoveToColorTemperature
				{
					struct Type;
					struct DecodableType;
				} // namespace MoveToColorTemperature

				namespace EnhancedMoveToHue
				{
					struct Type;
					struct DecodableType;
				} // namespace EnhancedMoveToHue

				namespace EnhancedMoveHue
				{
					struct Type;
					struct DecodableType;
				} // namespace EnhancedMoveHue

				namespace EnhancedStepHue
				{
					struct Type;
					struct DecodableType;
				} // namespace EnhancedStepHue

				namespace EnhancedMoveToHueAndSaturation
				{
					struct Type;
					struct DecodableType;
				} // namespace EnhancedMoveToHueAndSaturation

				namespace ColorLoopSet
				{
					struct Type;
					struct DecodableType;
				} // namespace ColorLoopSet

				namespace StopMoveStep
				{
					struct Type;
					struct DecodableType;
				} // namespace StopMoveStep

				namespace MoveColorTemperature
				{
					struct Type;
					struct DecodableType;
				} // namespace MoveColorTemperature

				namespace StepColorTemperature
				{
					struct Type;
					struct DecodableType;
				} // namespace StepColorTemperature

			} // namespace Commands

			namespace Commands
			{
				namespace MoveToHue
				{
					enum class Fields : uint8_t {
						kHue = 0,
						kDirection = 1,
						kTransitionTime = 2,
						kOptionsMask = 3,
						kOptionsOverride = 4,
					};

					struct Type {
					public:
						// Use GetCommandId instead of commandId directly to avoid naming
						// conflict with CommandIdentification in ExecutionOfACommand
						static constexpr CommandId GetCommandId()
						{
							return Commands::MoveToHue::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::ColorControl::Id;
						}

						uint8_t hue = static_cast<uint8_t>(0);
						DirectionEnum direction = static_cast<DirectionEnum>(0);
						uint16_t transitionTime = static_cast<uint16_t>(0);
						chip::BitMask<OptionsBitmap> optionsMask =
							static_cast<chip::BitMask<OptionsBitmap>>(0);
						chip::BitMask<OptionsBitmap> optionsOverride =
							static_cast<chip::BitMask<OptionsBitmap>>(0);

						CHIP_ERROR Encode(TLV::TLVWriter &aWriter, TLV::Tag aTag) const;

						using ResponseType = DataModel::NullObjectType;

						static constexpr bool MustUseTimedInvoke() { return false; }
					};

					struct DecodableType {
					public:
						static constexpr CommandId GetCommandId()
						{
							return Commands::MoveToHue::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::ColorControl::Id;
						}
						static constexpr bool kIsFabricScoped = false;

						uint8_t hue = static_cast<uint8_t>(0);
						DirectionEnum direction = static_cast<DirectionEnum>(0);
						uint16_t transitionTime = static_cast<uint16_t>(0);
						chip::BitMask<OptionsBitmap> optionsMask =
							static_cast<chip::BitMask<OptionsBitmap>>(0);
						chip::BitMask<OptionsBitmap> optionsOverride =
							static_cast<chip::BitMask<OptionsBitmap>>(0);

						CHIP_ERROR Decode(TLV::TLVReader &reader);
					};
				}; // namespace MoveToHue
				namespace MoveHue
				{
					enum class Fields : uint8_t {
						kMoveMode = 0,
						kRate = 1,
						kOptionsMask = 2,
						kOptionsOverride = 3,
					};

					struct Type {
					public:
						// Use GetCommandId instead of commandId directly to avoid naming
						// conflict with CommandIdentification in ExecutionOfACommand
						static constexpr CommandId GetCommandId()
						{
							return Commands::MoveHue::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::ColorControl::Id;
						}

						MoveModeEnum moveMode = static_cast<MoveModeEnum>(0);
						uint8_t rate = static_cast<uint8_t>(0);
						chip::BitMask<OptionsBitmap> optionsMask =
							static_cast<chip::BitMask<OptionsBitmap>>(0);
						chip::BitMask<OptionsBitmap> optionsOverride =
							static_cast<chip::BitMask<OptionsBitmap>>(0);

						CHIP_ERROR Encode(TLV::TLVWriter &aWriter, TLV::Tag aTag) const;

						using ResponseType = DataModel::NullObjectType;

						static constexpr bool MustUseTimedInvoke() { return false; }
					};

					struct DecodableType {
					public:
						static constexpr CommandId GetCommandId()
						{
							return Commands::MoveHue::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::ColorControl::Id;
						}
						static constexpr bool kIsFabricScoped = false;

						MoveModeEnum moveMode = static_cast<MoveModeEnum>(0);
						uint8_t rate = static_cast<uint8_t>(0);
						chip::BitMask<OptionsBitmap> optionsMask =
							static_cast<chip::BitMask<OptionsBitmap>>(0);
						chip::BitMask<OptionsBitmap> optionsOverride =
							static_cast<chip::BitMask<OptionsBitmap>>(0);

						CHIP_ERROR Decode(TLV::TLVReader &reader);
					};
				}; // namespace MoveHue
				namespace StepHue
				{
					enum class Fields : uint8_t {
						kStepMode = 0,
						kStepSize = 1,
						kTransitionTime = 2,
						kOptionsMask = 3,
						kOptionsOverride = 4,
					};

					struct Type {
					public:
						// Use GetCommandId instead of commandId directly to avoid naming
						// conflict with CommandIdentification in ExecutionOfACommand
						static constexpr CommandId GetCommandId()
						{
							return Commands::StepHue::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::ColorControl::Id;
						}

						StepModeEnum stepMode = static_cast<StepModeEnum>(0);
						uint8_t stepSize = static_cast<uint8_t>(0);
						uint8_t transitionTime = static_cast<uint8_t>(0);
						chip::BitMask<OptionsBitmap> optionsMask =
							static_cast<chip::BitMask<OptionsBitmap>>(0);
						chip::BitMask<OptionsBitmap> optionsOverride =
							static_cast<chip::BitMask<OptionsBitmap>>(0);

						CHIP_ERROR Encode(TLV::TLVWriter &aWriter, TLV::Tag aTag) const;

						using ResponseType = DataModel::NullObjectType;

						static constexpr bool MustUseTimedInvoke() { return false; }
					};

					struct DecodableType {
					public:
						static constexpr CommandId GetCommandId()
						{
							return Commands::StepHue::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::ColorControl::Id;
						}
						static constexpr bool kIsFabricScoped = false;

						StepModeEnum stepMode = static_cast<StepModeEnum>(0);
						uint8_t stepSize = static_cast<uint8_t>(0);
						uint8_t transitionTime = static_cast<uint8_t>(0);
						chip::BitMask<OptionsBitmap> optionsMask =
							static_cast<chip::BitMask<OptionsBitmap>>(0);
						chip::BitMask<OptionsBitmap> optionsOverride =
							static_cast<chip::BitMask<OptionsBitmap>>(0);

						CHIP_ERROR Decode(TLV::TLVReader &reader);
					};
				}; // namespace StepHue
				namespace MoveToSaturation
				{
					enum class Fields : uint8_t {
						kSaturation = 0,
						kTransitionTime = 1,
						kOptionsMask = 2,
						kOptionsOverride = 3,
					};

					struct Type {
					public:
						// Use GetCommandId instead of commandId directly to avoid naming
						// conflict with CommandIdentification in ExecutionOfACommand
						static constexpr CommandId GetCommandId()
						{
							return Commands::MoveToSaturation::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::ColorControl::Id;
						}

						uint8_t saturation = static_cast<uint8_t>(0);
						uint16_t transitionTime = static_cast<uint16_t>(0);
						chip::BitMask<OptionsBitmap> optionsMask =
							static_cast<chip::BitMask<OptionsBitmap>>(0);
						chip::BitMask<OptionsBitmap> optionsOverride =
							static_cast<chip::BitMask<OptionsBitmap>>(0);

						CHIP_ERROR Encode(TLV::TLVWriter &aWriter, TLV::Tag aTag) const;

						using ResponseType = DataModel::NullObjectType;

						static constexpr bool MustUseTimedInvoke() { return false; }
					};

					struct DecodableType {
					public:
						static constexpr CommandId GetCommandId()
						{
							return Commands::MoveToSaturation::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::ColorControl::Id;
						}
						static constexpr bool kIsFabricScoped = false;

						uint8_t saturation = static_cast<uint8_t>(0);
						uint16_t transitionTime = static_cast<uint16_t>(0);
						chip::BitMask<OptionsBitmap> optionsMask =
							static_cast<chip::BitMask<OptionsBitmap>>(0);
						chip::BitMask<OptionsBitmap> optionsOverride =
							static_cast<chip::BitMask<OptionsBitmap>>(0);

						CHIP_ERROR Decode(TLV::TLVReader &reader);
					};
				}; // namespace MoveToSaturation
				namespace MoveSaturation
				{
					enum class Fields : uint8_t {
						kMoveMode = 0,
						kRate = 1,
						kOptionsMask = 2,
						kOptionsOverride = 3,
					};

					struct Type {
					public:
						// Use GetCommandId instead of commandId directly to avoid naming
						// conflict with CommandIdentification in ExecutionOfACommand
						static constexpr CommandId GetCommandId()
						{
							return Commands::MoveSaturation::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::ColorControl::Id;
						}

						MoveModeEnum moveMode = static_cast<MoveModeEnum>(0);
						uint8_t rate = static_cast<uint8_t>(0);
						chip::BitMask<OptionsBitmap> optionsMask =
							static_cast<chip::BitMask<OptionsBitmap>>(0);
						chip::BitMask<OptionsBitmap> optionsOverride =
							static_cast<chip::BitMask<OptionsBitmap>>(0);

						CHIP_ERROR Encode(TLV::TLVWriter &aWriter, TLV::Tag aTag) const;

						using ResponseType = DataModel::NullObjectType;

						static constexpr bool MustUseTimedInvoke() { return false; }
					};

					struct DecodableType {
					public:
						static constexpr CommandId GetCommandId()
						{
							return Commands::MoveSaturation::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::ColorControl::Id;
						}
						static constexpr bool kIsFabricScoped = false;

						MoveModeEnum moveMode = static_cast<MoveModeEnum>(0);
						uint8_t rate = static_cast<uint8_t>(0);
						chip::BitMask<OptionsBitmap> optionsMask =
							static_cast<chip::BitMask<OptionsBitmap>>(0);
						chip::BitMask<OptionsBitmap> optionsOverride =
							static_cast<chip::BitMask<OptionsBitmap>>(0);

						CHIP_ERROR Decode(TLV::TLVReader &reader);
					};
				}; // namespace MoveSaturation
				namespace StepSaturation
				{
					enum class Fields : uint8_t {
						kStepMode = 0,
						kStepSize = 1,
						kTransitionTime = 2,
						kOptionsMask = 3,
						kOptionsOverride = 4,
					};

					struct Type {
					public:
						// Use GetCommandId instead of commandId directly to avoid naming
						// conflict with CommandIdentification in ExecutionOfACommand
						static constexpr CommandId GetCommandId()
						{
							return Commands::StepSaturation::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::ColorControl::Id;
						}

						StepModeEnum stepMode = static_cast<StepModeEnum>(0);
						uint8_t stepSize = static_cast<uint8_t>(0);
						uint8_t transitionTime = static_cast<uint8_t>(0);
						chip::BitMask<OptionsBitmap> optionsMask =
							static_cast<chip::BitMask<OptionsBitmap>>(0);
						chip::BitMask<OptionsBitmap> optionsOverride =
							static_cast<chip::BitMask<OptionsBitmap>>(0);

						CHIP_ERROR Encode(TLV::TLVWriter &aWriter, TLV::Tag aTag) const;

						using ResponseType = DataModel::NullObjectType;

						static constexpr bool MustUseTimedInvoke() { return false; }
					};

					struct DecodableType {
					public:
						static constexpr CommandId GetCommandId()
						{
							return Commands::StepSaturation::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::ColorControl::Id;
						}
						static constexpr bool kIsFabricScoped = false;

						StepModeEnum stepMode = static_cast<StepModeEnum>(0);
						uint8_t stepSize = static_cast<uint8_t>(0);
						uint8_t transitionTime = static_cast<uint8_t>(0);
						chip::BitMask<OptionsBitmap> optionsMask =
							static_cast<chip::BitMask<OptionsBitmap>>(0);
						chip::BitMask<OptionsBitmap> optionsOverride =
							static_cast<chip::BitMask<OptionsBitmap>>(0);

						CHIP_ERROR Decode(TLV::TLVReader &reader);
					};
				}; // namespace StepSaturation
				namespace MoveToHueAndSaturation
				{
					enum class Fields : uint8_t {
						kHue = 0,
						kSaturation = 1,
						kTransitionTime = 2,
						kOptionsMask = 3,
						kOptionsOverride = 4,
					};

					struct Type {
					public:
						// Use GetCommandId instead of commandId directly to avoid naming
						// conflict with CommandIdentification in ExecutionOfACommand
						static constexpr CommandId GetCommandId()
						{
							return Commands::MoveToHueAndSaturation::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::ColorControl::Id;
						}

						uint8_t hue = static_cast<uint8_t>(0);
						uint8_t saturation = static_cast<uint8_t>(0);
						uint16_t transitionTime = static_cast<uint16_t>(0);
						chip::BitMask<OptionsBitmap> optionsMask =
							static_cast<chip::BitMask<OptionsBitmap>>(0);
						chip::BitMask<OptionsBitmap> optionsOverride =
							static_cast<chip::BitMask<OptionsBitmap>>(0);

						CHIP_ERROR Encode(TLV::TLVWriter &aWriter, TLV::Tag aTag) const;

						using ResponseType = DataModel::NullObjectType;

						static constexpr bool MustUseTimedInvoke() { return false; }
					};

					struct DecodableType {
					public:
						static constexpr CommandId GetCommandId()
						{
							return Commands::MoveToHueAndSaturation::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::ColorControl::Id;
						}
						static constexpr bool kIsFabricScoped = false;

						uint8_t hue = static_cast<uint8_t>(0);
						uint8_t saturation = static_cast<uint8_t>(0);
						uint16_t transitionTime = static_cast<uint16_t>(0);
						chip::BitMask<OptionsBitmap> optionsMask =
							static_cast<chip::BitMask<OptionsBitmap>>(0);
						chip::BitMask<OptionsBitmap> optionsOverride =
							static_cast<chip::BitMask<OptionsBitmap>>(0);

						CHIP_ERROR Decode(TLV::TLVReader &reader);
					};
				}; // namespace MoveToHueAndSaturation
				namespace MoveToColor
				{
					enum class Fields : uint8_t {
						kColorX = 0,
						kColorY = 1,
						kTransitionTime = 2,
						kOptionsMask = 3,
						kOptionsOverride = 4,
					};

					struct Type {
					public:
						// Use GetCommandId instead of commandId directly to avoid naming
						// conflict with CommandIdentification in ExecutionOfACommand
						static constexpr CommandId GetCommandId()
						{
							return Commands::MoveToColor::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::ColorControl::Id;
						}

						uint16_t colorX = static_cast<uint16_t>(0);
						uint16_t colorY = static_cast<uint16_t>(0);
						uint16_t transitionTime = static_cast<uint16_t>(0);
						chip::BitMask<OptionsBitmap> optionsMask =
							static_cast<chip::BitMask<OptionsBitmap>>(0);
						chip::BitMask<OptionsBitmap> optionsOverride =
							static_cast<chip::BitMask<OptionsBitmap>>(0);

						CHIP_ERROR Encode(TLV::TLVWriter &aWriter, TLV::Tag aTag) const;

						using ResponseType = DataModel::NullObjectType;

						static constexpr bool MustUseTimedInvoke() { return false; }
					};

					struct DecodableType {
					public:
						static constexpr CommandId GetCommandId()
						{
							return Commands::MoveToColor::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::ColorControl::Id;
						}
						static constexpr bool kIsFabricScoped = false;

						uint16_t colorX = static_cast<uint16_t>(0);
						uint16_t colorY = static_cast<uint16_t>(0);
						uint16_t transitionTime = static_cast<uint16_t>(0);
						chip::BitMask<OptionsBitmap> optionsMask =
							static_cast<chip::BitMask<OptionsBitmap>>(0);
						chip::BitMask<OptionsBitmap> optionsOverride =
							static_cast<chip::BitMask<OptionsBitmap>>(0);

						CHIP_ERROR Decode(TLV::TLVReader &reader);
					};
				}; // namespace MoveToColor
				namespace MoveColor
				{
					enum class Fields : uint8_t {
						kRateX = 0,
						kRateY = 1,
						kOptionsMask = 2,
						kOptionsOverride = 3,
					};

					struct Type {
					public:
						// Use GetCommandId instead of commandId directly to avoid naming
						// conflict with CommandIdentification in ExecutionOfACommand
						static constexpr CommandId GetCommandId()
						{
							return Commands::MoveColor::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::ColorControl::Id;
						}

						int16_t rateX = static_cast<int16_t>(0);
						int16_t rateY = static_cast<int16_t>(0);
						chip::BitMask<OptionsBitmap> optionsMask =
							static_cast<chip::BitMask<OptionsBitmap>>(0);
						chip::BitMask<OptionsBitmap> optionsOverride =
							static_cast<chip::BitMask<OptionsBitmap>>(0);

						CHIP_ERROR Encode(TLV::TLVWriter &aWriter, TLV::Tag aTag) const;

						using ResponseType = DataModel::NullObjectType;

						static constexpr bool MustUseTimedInvoke() { return false; }
					};

					struct DecodableType {
					public:
						static constexpr CommandId GetCommandId()
						{
							return Commands::MoveColor::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::ColorControl::Id;
						}
						static constexpr bool kIsFabricScoped = false;

						int16_t rateX = static_cast<int16_t>(0);
						int16_t rateY = static_cast<int16_t>(0);
						chip::BitMask<OptionsBitmap> optionsMask =
							static_cast<chip::BitMask<OptionsBitmap>>(0);
						chip::BitMask<OptionsBitmap> optionsOverride =
							static_cast<chip::BitMask<OptionsBitmap>>(0);

						CHIP_ERROR Decode(TLV::TLVReader &reader);
					};
				}; // namespace MoveColor
				namespace StepColor
				{
					enum class Fields : uint8_t {
						kStepX = 0,
						kStepY = 1,
						kTransitionTime = 2,
						kOptionsMask = 3,
						kOptionsOverride = 4,
					};

					struct Type {
					public:
						// Use GetCommandId instead of commandId directly to avoid naming
						// conflict with CommandIdentification in ExecutionOfACommand
						static constexpr CommandId GetCommandId()
						{
							return Commands::StepColor::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::ColorControl::Id;
						}

						int16_t stepX = static_cast<int16_t>(0);
						int16_t stepY = static_cast<int16_t>(0);
						uint16_t transitionTime = static_cast<uint16_t>(0);
						chip::BitMask<OptionsBitmap> optionsMask =
							static_cast<chip::BitMask<OptionsBitmap>>(0);
						chip::BitMask<OptionsBitmap> optionsOverride =
							static_cast<chip::BitMask<OptionsBitmap>>(0);

						CHIP_ERROR Encode(TLV::TLVWriter &aWriter, TLV::Tag aTag) const;

						using ResponseType = DataModel::NullObjectType;

						static constexpr bool MustUseTimedInvoke() { return false; }
					};

					struct DecodableType {
					public:
						static constexpr CommandId GetCommandId()
						{
							return Commands::StepColor::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::ColorControl::Id;
						}
						static constexpr bool kIsFabricScoped = false;

						int16_t stepX = static_cast<int16_t>(0);
						int16_t stepY = static_cast<int16_t>(0);
						uint16_t transitionTime = static_cast<uint16_t>(0);
						chip::BitMask<OptionsBitmap> optionsMask =
							static_cast<chip::BitMask<OptionsBitmap>>(0);
						chip::BitMask<OptionsBitmap> optionsOverride =
							static_cast<chip::BitMask<OptionsBitmap>>(0);

						CHIP_ERROR Decode(TLV::TLVReader &reader);
					};
				}; // namespace StepColor
				namespace MoveToColorTemperature
				{
					enum class Fields : uint8_t {
						kColorTemperatureMireds = 0,
						kTransitionTime = 1,
						kOptionsMask = 2,
						kOptionsOverride = 3,
					};

					struct Type {
					public:
						// Use GetCommandId instead of commandId directly to avoid naming
						// conflict with CommandIdentification in ExecutionOfACommand
						static constexpr CommandId GetCommandId()
						{
							return Commands::MoveToColorTemperature::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::ColorControl::Id;
						}

						uint16_t colorTemperatureMireds = static_cast<uint16_t>(0);
						uint16_t transitionTime = static_cast<uint16_t>(0);
						chip::BitMask<OptionsBitmap> optionsMask =
							static_cast<chip::BitMask<OptionsBitmap>>(0);
						chip::BitMask<OptionsBitmap> optionsOverride =
							static_cast<chip::BitMask<OptionsBitmap>>(0);

						CHIP_ERROR Encode(TLV::TLVWriter &aWriter, TLV::Tag aTag) const;

						using ResponseType = DataModel::NullObjectType;

						static constexpr bool MustUseTimedInvoke() { return false; }
					};

					struct DecodableType {
					public:
						static constexpr CommandId GetCommandId()
						{
							return Commands::MoveToColorTemperature::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::ColorControl::Id;
						}
						static constexpr bool kIsFabricScoped = false;

						uint16_t colorTemperatureMireds = static_cast<uint16_t>(0);
						uint16_t transitionTime = static_cast<uint16_t>(0);
						chip::BitMask<OptionsBitmap> optionsMask =
							static_cast<chip::BitMask<OptionsBitmap>>(0);
						chip::BitMask<OptionsBitmap> optionsOverride =
							static_cast<chip::BitMask<OptionsBitmap>>(0);

						CHIP_ERROR Decode(TLV::TLVReader &reader);
					};
				}; // namespace MoveToColorTemperature
				namespace EnhancedMoveToHue
				{
					enum class Fields : uint8_t {
						kEnhancedHue = 0,
						kDirection = 1,
						kTransitionTime = 2,
						kOptionsMask = 3,
						kOptionsOverride = 4,
					};

					struct Type {
					public:
						// Use GetCommandId instead of commandId directly to avoid naming
						// conflict with CommandIdentification in ExecutionOfACommand
						static constexpr CommandId GetCommandId()
						{
							return Commands::EnhancedMoveToHue::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::ColorControl::Id;
						}

						uint16_t enhancedHue = static_cast<uint16_t>(0);
						DirectionEnum direction = static_cast<DirectionEnum>(0);
						uint16_t transitionTime = static_cast<uint16_t>(0);
						chip::BitMask<OptionsBitmap> optionsMask =
							static_cast<chip::BitMask<OptionsBitmap>>(0);
						chip::BitMask<OptionsBitmap> optionsOverride =
							static_cast<chip::BitMask<OptionsBitmap>>(0);

						CHIP_ERROR Encode(TLV::TLVWriter &aWriter, TLV::Tag aTag) const;

						using ResponseType = DataModel::NullObjectType;

						static constexpr bool MustUseTimedInvoke() { return false; }
					};

					struct DecodableType {
					public:
						static constexpr CommandId GetCommandId()
						{
							return Commands::EnhancedMoveToHue::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::ColorControl::Id;
						}
						static constexpr bool kIsFabricScoped = false;

						uint16_t enhancedHue = static_cast<uint16_t>(0);
						DirectionEnum direction = static_cast<DirectionEnum>(0);
						uint16_t transitionTime = static_cast<uint16_t>(0);
						chip::BitMask<OptionsBitmap> optionsMask =
							static_cast<chip::BitMask<OptionsBitmap>>(0);
						chip::BitMask<OptionsBitmap> optionsOverride =
							static_cast<chip::BitMask<OptionsBitmap>>(0);

						CHIP_ERROR Decode(TLV::TLVReader &reader);
					};
				}; // namespace EnhancedMoveToHue
				namespace EnhancedMoveHue
				{
					enum class Fields : uint8_t {
						kMoveMode = 0,
						kRate = 1,
						kOptionsMask = 2,
						kOptionsOverride = 3,
					};

					struct Type {
					public:
						// Use GetCommandId instead of commandId directly to avoid naming
						// conflict with CommandIdentification in ExecutionOfACommand
						static constexpr CommandId GetCommandId()
						{
							return Commands::EnhancedMoveHue::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::ColorControl::Id;
						}

						MoveModeEnum moveMode = static_cast<MoveModeEnum>(0);
						uint16_t rate = static_cast<uint16_t>(0);
						chip::BitMask<OptionsBitmap> optionsMask =
							static_cast<chip::BitMask<OptionsBitmap>>(0);
						chip::BitMask<OptionsBitmap> optionsOverride =
							static_cast<chip::BitMask<OptionsBitmap>>(0);

						CHIP_ERROR Encode(TLV::TLVWriter &aWriter, TLV::Tag aTag) const;

						using ResponseType = DataModel::NullObjectType;

						static constexpr bool MustUseTimedInvoke() { return false; }
					};

					struct DecodableType {
					public:
						static constexpr CommandId GetCommandId()
						{
							return Commands::EnhancedMoveHue::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::ColorControl::Id;
						}
						static constexpr bool kIsFabricScoped = false;

						MoveModeEnum moveMode = static_cast<MoveModeEnum>(0);
						uint16_t rate = static_cast<uint16_t>(0);
						chip::BitMask<OptionsBitmap> optionsMask =
							static_cast<chip::BitMask<OptionsBitmap>>(0);
						chip::BitMask<OptionsBitmap> optionsOverride =
							static_cast<chip::BitMask<OptionsBitmap>>(0);

						CHIP_ERROR Decode(TLV::TLVReader &reader);
					};
				}; // namespace EnhancedMoveHue
				namespace EnhancedStepHue
				{
					enum class Fields : uint8_t {
						kStepMode = 0,
						kStepSize = 1,
						kTransitionTime = 2,
						kOptionsMask = 3,
						kOptionsOverride = 4,
					};

					struct Type {
					public:
						// Use GetCommandId instead of commandId directly to avoid naming
						// conflict with CommandIdentification in ExecutionOfACommand
						static constexpr CommandId GetCommandId()
						{
							return Commands::EnhancedStepHue::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::ColorControl::Id;
						}

						StepModeEnum stepMode = static_cast<StepModeEnum>(0);
						uint16_t stepSize = static_cast<uint16_t>(0);
						uint16_t transitionTime = static_cast<uint16_t>(0);
						chip::BitMask<OptionsBitmap> optionsMask =
							static_cast<chip::BitMask<OptionsBitmap>>(0);
						chip::BitMask<OptionsBitmap> optionsOverride =
							static_cast<chip::BitMask<OptionsBitmap>>(0);

						CHIP_ERROR Encode(TLV::TLVWriter &aWriter, TLV::Tag aTag) const;

						using ResponseType = DataModel::NullObjectType;

						static constexpr bool MustUseTimedInvoke() { return false; }
					};

					struct DecodableType {
					public:
						static constexpr CommandId GetCommandId()
						{
							return Commands::EnhancedStepHue::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::ColorControl::Id;
						}
						static constexpr bool kIsFabricScoped = false;

						StepModeEnum stepMode = static_cast<StepModeEnum>(0);
						uint16_t stepSize = static_cast<uint16_t>(0);
						uint16_t transitionTime = static_cast<uint16_t>(0);
						chip::BitMask<OptionsBitmap> optionsMask =
							static_cast<chip::BitMask<OptionsBitmap>>(0);
						chip::BitMask<OptionsBitmap> optionsOverride =
							static_cast<chip::BitMask<OptionsBitmap>>(0);

						CHIP_ERROR Decode(TLV::TLVReader &reader);
					};
				}; // namespace EnhancedStepHue
				namespace EnhancedMoveToHueAndSaturation
				{
					enum class Fields : uint8_t {
						kEnhancedHue = 0,
						kSaturation = 1,
						kTransitionTime = 2,
						kOptionsMask = 3,
						kOptionsOverride = 4,
					};

					struct Type {
					public:
						// Use GetCommandId instead of commandId directly to avoid naming
						// conflict with CommandIdentification in ExecutionOfACommand
						static constexpr CommandId GetCommandId()
						{
							return Commands::EnhancedMoveToHueAndSaturation::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::ColorControl::Id;
						}

						uint16_t enhancedHue = static_cast<uint16_t>(0);
						uint8_t saturation = static_cast<uint8_t>(0);
						uint16_t transitionTime = static_cast<uint16_t>(0);
						chip::BitMask<OptionsBitmap> optionsMask =
							static_cast<chip::BitMask<OptionsBitmap>>(0);
						chip::BitMask<OptionsBitmap> optionsOverride =
							static_cast<chip::BitMask<OptionsBitmap>>(0);

						CHIP_ERROR Encode(TLV::TLVWriter &aWriter, TLV::Tag aTag) const;

						using ResponseType = DataModel::NullObjectType;

						static constexpr bool MustUseTimedInvoke() { return false; }
					};

					struct DecodableType {
					public:
						static constexpr CommandId GetCommandId()
						{
							return Commands::EnhancedMoveToHueAndSaturation::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::ColorControl::Id;
						}
						static constexpr bool kIsFabricScoped = false;

						uint16_t enhancedHue = static_cast<uint16_t>(0);
						uint8_t saturation = static_cast<uint8_t>(0);
						uint16_t transitionTime = static_cast<uint16_t>(0);
						chip::BitMask<OptionsBitmap> optionsMask =
							static_cast<chip::BitMask<OptionsBitmap>>(0);
						chip::BitMask<OptionsBitmap> optionsOverride =
							static_cast<chip::BitMask<OptionsBitmap>>(0);

						CHIP_ERROR Decode(TLV::TLVReader &reader);
					};
				}; // namespace EnhancedMoveToHueAndSaturation
				namespace ColorLoopSet
				{
					enum class Fields : uint8_t {
						kUpdateFlags = 0,
						kAction = 1,
						kDirection = 2,
						kTime = 3,
						kStartHue = 4,
						kOptionsMask = 5,
						kOptionsOverride = 6,
					};

					struct Type {
					public:
						// Use GetCommandId instead of commandId directly to avoid naming
						// conflict with CommandIdentification in ExecutionOfACommand
						static constexpr CommandId GetCommandId()
						{
							return Commands::ColorLoopSet::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::ColorControl::Id;
						}

						chip::BitMask<UpdateFlagsBitmap> updateFlags =
							static_cast<chip::BitMask<UpdateFlagsBitmap>>(0);
						ColorLoopActionEnum action = static_cast<ColorLoopActionEnum>(0);
						ColorLoopDirectionEnum direction =
							static_cast<ColorLoopDirectionEnum>(0);
						uint16_t time = static_cast<uint16_t>(0);
						uint16_t startHue = static_cast<uint16_t>(0);
						chip::BitMask<OptionsBitmap> optionsMask =
							static_cast<chip::BitMask<OptionsBitmap>>(0);
						chip::BitMask<OptionsBitmap> optionsOverride =
							static_cast<chip::BitMask<OptionsBitmap>>(0);

						CHIP_ERROR Encode(TLV::TLVWriter &aWriter, TLV::Tag aTag) const;

						using ResponseType = DataModel::NullObjectType;

						static constexpr bool MustUseTimedInvoke() { return false; }
					};

					struct DecodableType {
					public:
						static constexpr CommandId GetCommandId()
						{
							return Commands::ColorLoopSet::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::ColorControl::Id;
						}
						static constexpr bool kIsFabricScoped = false;

						chip::BitMask<UpdateFlagsBitmap> updateFlags =
							static_cast<chip::BitMask<UpdateFlagsBitmap>>(0);
						ColorLoopActionEnum action = static_cast<ColorLoopActionEnum>(0);
						ColorLoopDirectionEnum direction =
							static_cast<ColorLoopDirectionEnum>(0);
						uint16_t time = static_cast<uint16_t>(0);
						uint16_t startHue = static_cast<uint16_t>(0);
						chip::BitMask<OptionsBitmap> optionsMask =
							static_cast<chip::BitMask<OptionsBitmap>>(0);
						chip::BitMask<OptionsBitmap> optionsOverride =
							static_cast<chip::BitMask<OptionsBitmap>>(0);

						CHIP_ERROR Decode(TLV::TLVReader &reader);
					};
				}; // namespace ColorLoopSet
				namespace StopMoveStep
				{
					enum class Fields : uint8_t {
						kOptionsMask = 0,
						kOptionsOverride = 1,
					};

					struct Type {
					public:
						// Use GetCommandId instead of commandId directly to avoid naming
						// conflict with CommandIdentification in ExecutionOfACommand
						static constexpr CommandId GetCommandId()
						{
							return Commands::StopMoveStep::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::ColorControl::Id;
						}

						chip::BitMask<OptionsBitmap> optionsMask =
							static_cast<chip::BitMask<OptionsBitmap>>(0);
						chip::BitMask<OptionsBitmap> optionsOverride =
							static_cast<chip::BitMask<OptionsBitmap>>(0);

						CHIP_ERROR Encode(TLV::TLVWriter &aWriter, TLV::Tag aTag) const;

						using ResponseType = DataModel::NullObjectType;

						static constexpr bool MustUseTimedInvoke() { return false; }
					};

					struct DecodableType {
					public:
						static constexpr CommandId GetCommandId()
						{
							return Commands::StopMoveStep::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::ColorControl::Id;
						}
						static constexpr bool kIsFabricScoped = false;

						chip::BitMask<OptionsBitmap> optionsMask =
							static_cast<chip::BitMask<OptionsBitmap>>(0);
						chip::BitMask<OptionsBitmap> optionsOverride =
							static_cast<chip::BitMask<OptionsBitmap>>(0);

						CHIP_ERROR Decode(TLV::TLVReader &reader);
					};
				}; // namespace StopMoveStep
				namespace MoveColorTemperature
				{
					enum class Fields : uint8_t {
						kMoveMode = 0,
						kRate = 1,
						kColorTemperatureMinimumMireds = 2,
						kColorTemperatureMaximumMireds = 3,
						kOptionsMask = 4,
						kOptionsOverride = 5,
					};

					struct Type {
					public:
						// Use GetCommandId instead of commandId directly to avoid naming
						// conflict with CommandIdentification in ExecutionOfACommand
						static constexpr CommandId GetCommandId()
						{
							return Commands::MoveColorTemperature::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::ColorControl::Id;
						}

						MoveModeEnum moveMode = static_cast<MoveModeEnum>(0);
						uint16_t rate = static_cast<uint16_t>(0);
						uint16_t colorTemperatureMinimumMireds = static_cast<uint16_t>(0);
						uint16_t colorTemperatureMaximumMireds = static_cast<uint16_t>(0);
						chip::BitMask<OptionsBitmap> optionsMask =
							static_cast<chip::BitMask<OptionsBitmap>>(0);
						chip::BitMask<OptionsBitmap> optionsOverride =
							static_cast<chip::BitMask<OptionsBitmap>>(0);

						CHIP_ERROR Encode(TLV::TLVWriter &aWriter, TLV::Tag aTag) const;

						using ResponseType = DataModel::NullObjectType;

						static constexpr bool MustUseTimedInvoke() { return false; }
					};

					struct DecodableType {
					public:
						static constexpr CommandId GetCommandId()
						{
							return Commands::MoveColorTemperature::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::ColorControl::Id;
						}
						static constexpr bool kIsFabricScoped = false;

						MoveModeEnum moveMode = static_cast<MoveModeEnum>(0);
						uint16_t rate = static_cast<uint16_t>(0);
						uint16_t colorTemperatureMinimumMireds = static_cast<uint16_t>(0);
						uint16_t colorTemperatureMaximumMireds = static_cast<uint16_t>(0);
						chip::BitMask<OptionsBitmap> optionsMask =
							static_cast<chip::BitMask<OptionsBitmap>>(0);
						chip::BitMask<OptionsBitmap> optionsOverride =
							static_cast<chip::BitMask<OptionsBitmap>>(0);

						CHIP_ERROR Decode(TLV::TLVReader &reader);
					};
				}; // namespace MoveColorTemperature
				namespace StepColorTemperature
				{
					enum class Fields : uint8_t {
						kStepMode = 0,
						kStepSize = 1,
						kTransitionTime = 2,
						kColorTemperatureMinimumMireds = 3,
						kColorTemperatureMaximumMireds = 4,
						kOptionsMask = 5,
						kOptionsOverride = 6,
					};

					struct Type {
					public:
						// Use GetCommandId instead of commandId directly to avoid naming
						// conflict with CommandIdentification in ExecutionOfACommand
						static constexpr CommandId GetCommandId()
						{
							return Commands::StepColorTemperature::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::ColorControl::Id;
						}

						StepModeEnum stepMode = static_cast<StepModeEnum>(0);
						uint16_t stepSize = static_cast<uint16_t>(0);
						uint16_t transitionTime = static_cast<uint16_t>(0);
						uint16_t colorTemperatureMinimumMireds = static_cast<uint16_t>(0);
						uint16_t colorTemperatureMaximumMireds = static_cast<uint16_t>(0);
						chip::BitMask<OptionsBitmap> optionsMask =
							static_cast<chip::BitMask<OptionsBitmap>>(0);
						chip::BitMask<OptionsBitmap> optionsOverride =
							static_cast<chip::BitMask<OptionsBitmap>>(0);

						CHIP_ERROR Encode(TLV::TLVWriter &aWriter, TLV::Tag aTag) const;

						using ResponseType = DataModel::NullObjectType;

						static constexpr bool MustUseTimedInvoke() { return false; }
					};

					struct DecodableType {
					public:
						static constexpr CommandId GetCommandId()
						{
							return Commands::StepColorTemperature::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::ColorControl::Id;
						}
						static constexpr bool kIsFabricScoped = false;

						StepModeEnum stepMode = static_cast<StepModeEnum>(0);
						uint16_t stepSize = static_cast<uint16_t>(0);
						uint16_t transitionTime = static_cast<uint16_t>(0);
						uint16_t colorTemperatureMinimumMireds = static_cast<uint16_t>(0);
						uint16_t colorTemperatureMaximumMireds = static_cast<uint16_t>(0);
						chip::BitMask<OptionsBitmap> optionsMask =
							static_cast<chip::BitMask<OptionsBitmap>>(0);
						chip::BitMask<OptionsBitmap> optionsOverride =
							static_cast<chip::BitMask<OptionsBitmap>>(0);

						CHIP_ERROR Decode(TLV::TLVReader &reader);
					};
				}; // namespace StepColorTemperature
			} // namespace Commands
		} // namespace ColorControl
	} // namespace Clusters
} // namespace app
} // namespace chip
